CS 320-- Summer 2019: Quiz Two Study Guide and Practice Problems

General Comments

• The second and final CS 320 quiz will be Monday June 24th in the same lecture room.

• The exam will consist of 4 problems, and you will be required to eliminate one of them, leaving 3 to do for full credit. You may not improve your score by doing all four. If you do not eliminate a problem, I will grade problems 1 through 3. In other words, same format as first quiz.

• It will cover lectures 10 - 17, and Hutton chapters 12 and 15 (except for 12.2, 15.6, and 15.7). From lecture 17 the only thing I want you to know about is the distinction between dynamic and static/lexical scoping for function definitions (and for which there will be practice problems). The material in chapter 13 is for background, you don't need know anything specific from this chapter; you should rather understand the parsers that you wrote for various assignments.

• Problems on the exam will be similar to homework problems (both analytical and code) but adapted (usually, simplified and shortened) to work as one of 3 problems on an hour exam. Most problems will have multiple parts.

• I will attempt to cover broadly the range of material (e.g., you won't have 4 questions about monads). Problems will very similar to those in homeworks 3 and 4 and in the practice problems listed below.

• The coding questions will be graded with an eye towards your understanding of the concept, not the exact details of Haskell syntax.

• There will be NO questions about the following topics:
  • Applicatives (e.g., section 12.2)
  • Lazy Evaluation (except as it concerns infinite lists and simultaneous let expressions).
  • Anything in lecture 17&18 except the lexical vs dynamic scope issue, e.g., you don't need to review the strict evaluation operator $!, closures, environments, the run-time stack.
  • Any exercises from Hutton.
  • Drawing syntax trees of lambda expressions.

Practice Problems

Here are practice problems on various topics we have covered; these are a work in progress and NOT comprehensive, and I did not repeat exactly the same kind of examples I showed in lecture. Having a set of practice problems here does not mean that that topic is more important for the exam than a topic for which there are no practice problems (hopefully in time I will cover all topics equally). They are completely optional, and feel free to skip if they seem too easy, or raise for discussion on Piazza if they are hard.

Click on the links below to access the practice problems:

(A) Understanding let expressions and lambda expressions: scope of local variables in Python and Java;.

(B) Resolving Non-Local (Free) Variables in Java, Python, and Haskell; Dynamic vs Lexical Scope in Python and Haskell..

(C) Beta-Reduction of Lambda Expressions.

(D) Infinite Lists.

(E) Context-Free Grammars, Parse Trees, and Languages.

(F) Monads, using Maybe monad as example. .